Layoffs are still dragging on and industry veterans are finding it hard to get a callback from recruiters. However, wage gains secured during the good days are still massive, despite what inflation has eroded over the last few years. Developers are still looking mighty privileged compared to premium programmers from a decade ago. AI will have a huge impact on the industry - no profession has ever successfully resisted automation or redundancy in the face of technological advancement over the long term.

SWE-agent gets 12% on 100% of SWE bench. It uses GPT-4 to help it write software and solve PRs.

Building a time zone conversion layer on top of a datetime library sounds like an easy task, but it isn't. This article lists 21 misconceptions about time zones the author had before attempting to write a time zone conversion app as well as extra misconceptions from readers. These misconceptions include thinking that there are more countries in the world than time zones, that every time zone has exactly one agreed-upon name, or that time zones are always offset from UTC by an integer number of hours.

Titles help normalize pay ranges and allow for progression and evaluation. People who are not job hoppers or get stuck in the same company and title due to laziness, comfort, or other reasons are unfortunately prone to 'The Curse of the Senior Software Engineer'. This is when an engineer who has been senior for too long finds themselves between two worlds upon their next job search: they are too senior to be hired as a senior or they have too little leadership experience to be hired in a leadership position. Avoiding the curse involves either playing by corporate rules or exiting the game by switching to self-employment.

Dropflow is a CSS layout engine with a high-quality text layout implementation capable of displaying many languages. It can generate PDFs or images and render rich wrapped text to a canvas in the browser. Dropflow supports bidirectional and RTL text, font fallbacks at the grapheme level, colored diacritics, optimized shaping, and much more.

Bun is an all-in-one toolkit for running, building, testing, and debugging JavaScript and TypeScript. Its 1.1 update contains thousands of bug fixes, tons of new features and APIs, and Windows support. This post details the changes in Bun 1.1. The Bun team is currently hiring for its in-person team in San Francisco.

SWE-agent turns LLMs (e.g. GPT-4) into software engineering agents that can fix bugs and issues in real GitHub repositories. SWE-agent sets the state-of-the-art performance on the full SWE-bench benchmark, resolving 12.29% of issues.

Production code can adopt elements of the prototype mindset, blurring the distinction between the two. Stewart Brand's pace layers concept delineates components of civilization with varying change rates and scales. This concept aids in decision-making regarding project fidelity and challenges traditional development approaches by slicing features into distinct deliverable layers.

The things that slow devs down depend on the company size, culture, the nature of the product, and the composition of the team. This article looks at what engineers from big tech companies think is slowing them down. Many devs say that build, compile, and deployment times are the main things slowing them down. Other factors include dependency bugs, complicated codebases, development processes, tests, and reviews.

Princeton has released a SWE agent that uses LLMs to fix bugs and issues in real GitHub repositories.

The most fundamental goal of software design is to make code understandable. Understandable code is needed for correctness, security, and performance, as a lack of understanding leads to defects, security issues, and misguided performance optimizations. Focusing on understandability means making the code itself readable and providing supporting documentation to clarify complex concepts or system architecture.

Engineering crits at Figma are collaborative sessions designed to foster brainstorming, knowledge sharing, and problem-solving early in the development process. Inspired by design critiques, Figma uses FigJam to facilitate asynchronous feedback, ensuring everyone’s perspectives are included in the conversation. Unlike traditional reviews, engineering crits emphasize suggestions over mandates.

To better estimate software projects, it’s helpful to break them down into smaller, well-defined tasks. This process starts with a high-level goal and iteratively expands tasks until they are clear enough for a developer to understand what needs to be done and how to know when it's complete.

Developers sometimes prioritize code perfection over delivering value to customers, leading to negative effects for both teams and customers. Teams should shift their focus to smaller, more frequent deliveries that provide immediate value to the customer, even if temporarily sacrificing some code quality. By breaking down large projects into smaller increments and limiting work-in-progress, developers can significantly shorten development cycles and have happier customers.

Projects benefit from investing upfront in foundational elements like READMEs, developer docs, websites, and clear process documentation. Code quality should always be upheld on the main branch. These kinds of elements are a productivity multiplier when a project gets larger and are much harder to introduce into a large project that doesn't already have them.

Software projects often fail due to hidden complexities and human factors rather than technical shortcomings. Overconfident developers can underestimate task complexity and the challenges of using new technologies or third-party dependencies. Inexperienced managers may prioritize personal ambitions over project success, lack firm leadership, or cave to every change imposed by higher-ups. Projects can become zombies, draining resources without delivering value, as stakeholders become reluctant to admit defeat due to fear or embarrassment.

This author started a project of automating a simple Unreal Engine task, but it quickly spiraled into an overly complex solution. His first attempt was a PowerShell script to delete specific project folders, but this evolved into a full-blown Windows installer using GitHub Actions to build a release. Eventually, he decided to use the language Zig to build an executable for the script, but Zig’s low-level nature proved hard to work with.

Years of encountering slow, unreliable tests and fixing bugs without adding tests have shaken this author’s faith in testing as the ultimate quality indicator. There are many high-quality projects that run surprisingly few tests. The key to software quality isn't the amount of testing, but rather prioritizing tests based on developer judgment and having developers that deeply care about their work.

Before starting a refactor, developers should carefully assess the potential costs of failure (lost revenue, damaged trust, etc.) and how those risks can be mitigated. Refactors should be isolated from feature development and be rigorously tested. Sometimes, the best choice can be to not do a refactor.

Software development is more than just coding. AI tools like ChatGPT help with specific tasks, but they can't replace the full range of developer responsibilities, which include design, deployment, gathering requirements, and more. Engineering is also about managing complexity - AI may not be able to translate business problems into software solutions properly. The market for technology is expanding, so while AI may automate some tasks, the overall demand to solve business problems will continue to grow.

Meta’s build systems follow a two-step process. The first step generates instructions for what to build and the second step executes the build. This separation makes them inflexible, as you can't add new files without re-running the first step. "End-to-end" (E2E) systems combine both steps, allowing for dynamic target discovery. In these systems, cloud caching, early cutoff, suspending schedulers, and minimal builds are all features easier to implement correctly.

Distractions while programming can easily derail focus and productivity. To combat distractions, developers should invest in personal organization (using tools like GTD or Zettelkasten) and master tools like editors, programming, and languages. Developers can free up brainpower for deeper problem-solving and more focus by automating common tasks and internalizing the mechanics of their tools.

This developer creates novel, fundamental algorithms and data structures designed to solve specific computing challenges and improve performance. Unlike common open-source models, they license these algorithms with a fee for use in closed-source projects, allowing them to make a lot of money from organizations that can easily afford it.

Slack automated deployments with a program called ReleaseBot. ReleaseBot monitors deployments, detects anomalies using z-scores and dynamic thresholds, and can pause or roll back deployments if necessary. This proved to be a big improvement compared to Slack’s previous process, which involved engineers serving as “Deployment Commanders” that oversaw manual deploys.

PostgreSQL would be easier to develop with if it had versioned schema, better online schema migrations, and declarative state-based migrations.

Syntax highlighting today uses color to distinguish code elements, but this doesn’t fully utilize the power of color to convey information. We could use dynamic color highlighting overlays to communicate things like scope, imports, argument flow, types, or even metadata about test failures.

Fear leads to overly cautious behavior and can hinder important code or system changes. Tools and team processes like version control, testing, and blameless postmortems can help mitigate fear. Programmers should feel comfortable making changes without the fear of breaking things or facing punishment. While some fears may be irrational, overcoming them through positive experiences can build confidence and improve software development.

The debate between using threads and async/await in Rust revolves around simplicity, performance, and composability. While threads may offer familiarity and straightforwardness, async/await is better in I/O-bound scenarios due to its composable code.

GitHub Copilot analyzes code in your editor to understand what you’re working on and then sends gathered context to a backend service that sanitizes the input by removing harmful content and irrelevant prompts. The cleaned prompt is run through OpenAI’s ChatGPT API and then a final suggestion is presented in your editor.

To ship code faster, identify where you spend most of your time: design, coding, testing, review, or deployment. If you’re new to a codebase, focus on understanding code flow, tracing techniques, and learning from experienced colleagues. To optimize testing and review, use feature flags, batch changes, automate testing, and aim for smaller, well-explained code changes for faster reviews.